package FFT;

public class FFTAnalyzer
{
	public double[][] ergebnisArray;
	private double[][] werteArray;
	private long samplingFrequenz;
	int z = 0;
	long NFFT = 0;
	float guranteedPowerOfTwo = 0;
	int countPowerOfTwo = 0;
	int start;
	int k;
	int begrenzung = 0;

	public FFTAnalyzer(long laenge, long samplingFrequenz, double[][] werteArray)
	{
		ergebnisArray = new double[2][10];
		this.werteArray = werteArray;
		this.samplingFrequenz = samplingFrequenz;
	}

	public void runThreads() throws InterruptedException
	{
		// set all zero
		for (int i = 0; i < ergebnisArray[0].length; i++)
		{
			for (int z = 0; z < 10; z++)
			{
				ergebnisArray[0][z] = 0;
				ergebnisArray[1][z] = 0;
			}
		}
		for (int j = 0; j < werteArray[0].length - 1;)
		{
			int schrittWeite = (int) samplingFrequenz;
			countPowerOfTwo = 0;
			NFFT = 0;

			// schrittWeite is shorter at the end
			if (j + schrittWeite > werteArray[0].length)
				schrittWeite = werteArray[0].length % schrittWeite - 1;

			guranteedPowerOfTwo = schrittWeite;

			// guaranteed power of 2
			while (guranteedPowerOfTwo > 1)
			{
				guranteedPowerOfTwo /= 2;
				countPowerOfTwo++;
			}
			guranteedPowerOfTwo /= 2;

			// set schrittWeite to power of 2
			if (guranteedPowerOfTwo != 0.5)
			{
				schrittWeite = (int) Math.pow((double) 2,
						(double) countPowerOfTwo);
			}

			Complex[] ersterKanal = new Complex[schrittWeite];
			Complex[] zweiterKanal = new Complex[schrittWeite];

			// original data, convert to datatype complex
			z = 0;
			for (int i = j; i < j + schrittWeite; i++)
			{
				if (i > werteArray[0].length - 1)
				{ // fill array with 0 if array shorter than destination array
					ersterKanal[z] = new Complex(0, 0);
					zweiterKanal[z] = new Complex(0, 0);
				} else
				{ // fill array with complex numbers
					ersterKanal[z] = new Complex(werteArray[0][i], 0);
					zweiterKanal[z] = new Complex(werteArray[1][i], 0);
				}
				z++;
			}

			NFFT = schrittWeite;

			// get frequenzy for array
			double[] frequenzArray = new double[(int) (NFFT / 2 + 1)];
			double schrittWeiteFrequenz = ((double) 1 / (double) (NFFT / 2 + 1))*10;
			double schrittWeiteAddition = schrittWeiteFrequenz;
			frequenzArray[0] = 0;
			for (int i = 1; i < NFFT / 2 + 1; i++)
			{
				frequenzArray[i] = schrittWeiteAddition * samplingFrequenz / 2;
				schrittWeiteAddition += schrittWeiteFrequenz;
			}

			// FFT of original data
			Complex[] complexErsterKanal = FFT.fft(ersterKanal);
			Complex[] complexZweiterKanal = FFT.fft(zweiterKanal);
			for (int i = 0; i < frequenzArray.length; i++)
			{
				// convert from complex to real and standardize
				// split in frequenzyparts 31; 62; 125; 250; 500; 1K; 2K; 4k;
				// 8K;
				// 16;
				if (frequenzArray[i] <= 46.5)
				{ // frequenzy under 46.5 Hz
					if (ergebnisArray[0][0] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[0][0] = 2 * (complexErsterKanal[i]
								.abs() / ersterKanal.length);
					if (ergebnisArray[1][0] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[1][0] = 2 * (complexZweiterKanal[i]
								.abs() / zweiterKanal.length);
				}
				if (frequenzArray[i] > 46.5 && frequenzArray[i] <= 93.5)
				{ // frequenzy between 46.5 Hz and 93.5 Hz
					if (ergebnisArray[0][1] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[0][1] = 2 * (complexErsterKanal[i]
								.abs() / ersterKanal.length);
					if (ergebnisArray[1][1] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[1][1] = 2 * (complexZweiterKanal[i]
								.abs() / zweiterKanal.length);
				}
				if (frequenzArray[i] > 93.5 && frequenzArray[i] <= 187.5)
				{ // frequenzy between 93.5 Hz and 187.5 Hz
					if (ergebnisArray[0][2] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[0][2] = 2 * (complexErsterKanal[i]
								.abs() / ersterKanal.length);
					if (ergebnisArray[1][2] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[1][2] = 2 * (complexZweiterKanal[i]
								.abs() / zweiterKanal.length);
				}
				if (frequenzArray[i] > 187.5 && frequenzArray[i] <= 375)
				{ // frequenzy between 187.5 Hz and 375 Hz
					if (ergebnisArray[0][3] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[0][3] = 2 * (complexErsterKanal[i]
								.abs() / ersterKanal.length);
					if (ergebnisArray[1][3] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[1][3] = 2 * (complexZweiterKanal[i]
								.abs() / zweiterKanal.length);
				}
				if (frequenzArray[i] > 375 && frequenzArray[i] <= 750)
				{ // frequenzy between 375 Hz and 750 Hz
					if (ergebnisArray[0][4] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[0][4] = 2 * (complexErsterKanal[i]
								.abs() / ersterKanal.length);
					if (ergebnisArray[1][4] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[1][4] = 2 * (complexZweiterKanal[i]
								.abs() / zweiterKanal.length);
				}
				if (frequenzArray[i] > 750 && frequenzArray[i] <= 1500)
				{ // frequenzy between 750 Hz and 1500 Hz
					if (ergebnisArray[0][5] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[0][5] = 2 * (complexErsterKanal[i]
								.abs() / ersterKanal.length);
					if (ergebnisArray[1][5] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[1][5] = 2 * (complexZweiterKanal[i]
								.abs() / zweiterKanal.length);
				}
				if (frequenzArray[i] > 1500 && frequenzArray[i] <= 3000)
				{ // frequenzy between 1500 Hz and 3000 Hz
					if (ergebnisArray[0][6] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[0][6] = 2 * (complexErsterKanal[i]
								.abs() / ersterKanal.length);
					if (ergebnisArray[1][6] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[1][6] = 2 * (complexZweiterKanal[i]
								.abs() / zweiterKanal.length);
				}
				if (frequenzArray[i] > 3000 && frequenzArray[i] <= 6000)
				{ // frequenzy between 3000 Hz and 6000 Hz
					if (ergebnisArray[0][7] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[0][7] = 2 * (complexErsterKanal[i]
								.abs() / ersterKanal.length);
					if (ergebnisArray[1][7] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[1][7] = 2 * (complexZweiterKanal[i]
								.abs() / zweiterKanal.length);
				}
				if (frequenzArray[i] > 6000 && frequenzArray[i] <= 12000)
				{ // frequenzy between 6000 Hz and 12000 Hz
					if (ergebnisArray[0][8] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[0][8] = 2 * (complexErsterKanal[i]
								.abs() / ersterKanal.length);
					if (ergebnisArray[1][8] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[1][8] = 2 * (complexZweiterKanal[i]
								.abs() / zweiterKanal.length);
				}
				if (frequenzArray[i] > 12000)
				{ // frequenzy over 12000 Hz
					if (ergebnisArray[0][9] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[0][9] = 2 * (complexErsterKanal[i]
								.abs() / ersterKanal.length);
					if (ergebnisArray[1][9] < (2 * (complexErsterKanal[i]
							.abs() / ersterKanal.length)))
						ergebnisArray[1][9] = 2 * (complexZweiterKanal[i]
								.abs() / zweiterKanal.length);
				}
			}
			j = (int) (j + samplingFrequenz);
		}
	}
}